﻿using Resn.WhuPub.BLL;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using Resn.WhuPub.DML;
using Resn.WhuPub.BIL;

namespace Resn.WhuPub.UnitTest
{
    
    
    /// <summary>
    ///这是 DealerTest 的测试类，旨在
    ///包含所有 DealerTest 单元测试
    ///</summary>
        [TestClass()]
        public class DealerTest
        {


                private TestContext testContextInstance;

                /// <summary>
                ///获取或设置测试上下文，上下文提供
                ///有关当前测试运行及其功能的信息。
                ///</summary>
                public TestContext TestContext
                {
                        get
                        {
                                return testContextInstance;
                        }
                        set
                        {
                                testContextInstance = value;
                        }
                }

                #region 附加测试特性
                // 
                //编写测试时，还可使用以下特性:
                //
                //使用 ClassInitialize 在运行类中的第一个测试前先运行代码
                //[ClassInitialize()]
                //public static void MyClassInitialize(TestContext testContext)
                //{
                //}
                //
                //使用 ClassCleanup 在运行完类中的所有测试后再运行代码
                //[ClassCleanup()]
                //public static void MyClassCleanup()
                //{
                //}
                //
                //使用 TestInitialize 在运行每个测试前先运行代码
                //[TestInitialize()]
                //public void MyTestInitialize()
                //{
                //}
                //
                //使用 TestCleanup 在运行完每个测试后运行代码
                //[TestCleanup()]
                //public void MyTestCleanup()
                //{
                //}
                //
                #endregion


                /// <summary>
                ///Dealer 构造函数 的测试
                ///</summary>
                [TestMethod()]
                public void DealerConstructorTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model);
                        Assert.Inconclusive("TODO: 实现用来验证目标的代码");
                }

                /// <summary>
                ///CreateInvoiceDelivery 的测试
                ///</summary>
                [TestMethod()]
                public void CreateInvoiceDeliveryTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string billingEmployeeId = string.Empty; // TODO: 初始化为适当的值
                        string billingNumber = string.Empty; // TODO: 初始化为适当的值
                        string billingTime = string.Empty; // TODO: 初始化为适当的值
                        double billingAmount = 0F; // TODO: 初始化为适当的值
                        string deliveryNumber = string.Empty; // TODO: 初始化为适当的值
                        DateTime deliveryTime = new DateTime(); // TODO: 初始化为适当的值
                        IInvoiceDelivery expected = null; // TODO: 初始化为适当的值
                        IInvoiceDelivery actual;
                        actual = target.CreateInvoiceDelivery(billingEmployeeId, billingNumber, billingTime, billingAmount, deliveryNumber, deliveryTime);
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Select 的测试
                ///</summary>
                [TestMethod()]
                public void SelectTest()
                {
                        string id = string.Empty; // TODO: 初始化为适当的值
                        Dealer expected = null; // TODO: 初始化为适当的值
                        Dealer actual;
                        actual = Dealer.Select(id);
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///BankAccount 的测试
                ///</summary>
                [TestMethod()]
                public void BankAccountTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.BankAccount = expected;
                        actual = target.BankAccount;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///BankName 的测试
                ///</summary>
                [TestMethod()]
                public void BankNameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.BankName = expected;
                        actual = target.BankName;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///BusinessAddress 的测试
                ///</summary>
                [TestMethod()]
                public void BusinessAddressTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.BusinessAddress = expected;
                        actual = target.BusinessAddress;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///City 的测试
                ///</summary>
                [TestMethod()]
                public void CityTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.City = expected;
                        actual = target.City;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ConsigneeAddress 的测试
                ///</summary>
                [TestMethod()]
                public void ConsigneeAddressTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ConsigneeAddress = expected;
                        actual = target.ConsigneeAddress;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ConsigneeName 的测试
                ///</summary>
                [TestMethod()]
                public void ConsigneeNameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ConsigneeName = expected;
                        actual = target.ConsigneeName;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ConsigneeTelephone 的测试
                ///</summary>
                [TestMethod()]
                public void ConsigneeTelephoneTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ConsigneeTelephone = expected;
                        actual = target.ConsigneeTelephone;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ContactEmail 的测试
                ///</summary>
                [TestMethod()]
                public void ContactEmailTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ContactEmail = expected;
                        actual = target.ContactEmail;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ContactFax 的测试
                ///</summary>
                [TestMethod()]
                public void ContactFaxTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ContactFax = expected;
                        actual = target.ContactFax;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ContactName 的测试
                ///</summary>
                [TestMethod()]
                public void ContactNameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ContactName = expected;
                        actual = target.ContactName;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ContactTelephone 的测试
                ///</summary>
                [TestMethod()]
                public void ContactTelephoneTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ContactTelephone = expected;
                        actual = target.ContactTelephone;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///FinanceName 的测试
                ///</summary>
                [TestMethod()]
                public void FinanceNameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.FinanceName = expected;
                        actual = target.FinanceName;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///FinanceTelephone 的测试
                ///</summary>
                [TestMethod()]
                public void FinanceTelephoneTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.FinanceTelephone = expected;
                        actual = target.FinanceTelephone;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///LegalName 的测试
                ///</summary>
                [TestMethod()]
                public void LegalNameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.LegalName = expected;
                        actual = target.LegalName;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///LegalTelephone 的测试
                ///</summary>
                [TestMethod()]
                public void LegalTelephoneTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.LegalTelephone = expected;
                        actual = target.LegalTelephone;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///MainBusiness 的测试
                ///</summary>
                [TestMethod()]
                public void MainBusinessTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.MainBusiness = expected;
                        actual = target.MainBusiness;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ManagerName 的测试
                ///</summary>
                [TestMethod()]
                public void ManagerNameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ManagerName = expected;
                        actual = target.ManagerName;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ManagerTelephone 的测试
                ///</summary>
                [TestMethod()]
                public void ManagerTelephoneTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ManagerTelephone = expected;
                        actual = target.ManagerTelephone;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Model 的测试
                ///</summary>
                [TestMethod()]
                [DeploymentItem("Resn.WhuPub.BLL.dll")]
                public void ModelTest()
                {
                        PrivateObject param0 = null; // TODO: 初始化为适当的值
                        Dealer_Accessor target = new Dealer_Accessor(param0); // TODO: 初始化为适当的值
                        DealerModel expected = null; // TODO: 初始化为适当的值
                        DealerModel actual;
                        target.Model = expected;
                        actual = target.Model;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Name 的测试
                ///</summary>
                [TestMethod()]
                public void NameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Name = expected;
                        actual = target.Name;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Postcode 的测试
                ///</summary>
                [TestMethod()]
                public void PostcodeTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Postcode = expected;
                        actual = target.Postcode;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Province 的测试
                ///</summary>
                [TestMethod()]
                public void ProvinceTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Province = expected;
                        actual = target.Province;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///RegisterAddress 的测试
                ///</summary>
                [TestMethod()]
                public void RegisterAddressTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.RegisterAddress = expected;
                        actual = target.RegisterAddress;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///TaxAccount 的测试
                ///</summary>
                [TestMethod()]
                public void TaxAccountTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.TaxAccount = expected;
                        actual = target.TaxAccount;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///TaxAddress 的测试
                ///</summary>
                [TestMethod()]
                public void TaxAddressTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.TaxAddress = expected;
                        actual = target.TaxAddress;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///TaxName 的测试
                ///</summary>
                [TestMethod()]
                public void TaxNameTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.TaxName = expected;
                        actual = target.TaxName;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///TaxTelephone 的测试
                ///</summary>
                [TestMethod()]
                public void TaxTelephoneTest()
                {
                        DealerModel model = null; // TODO: 初始化为适当的值
                        Dealer target = new Dealer(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.TaxTelephone = expected;
                        actual = target.TaxTelephone;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }
        }
}
